package yxm.zyf.love.annontation.minganci;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

import java.io.File;
import java.io.IOException;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * @Description Java实现敏感词过滤：http://blog.csdn.net/chenssy/article/details/26961957
 * @Author jie.zhao
 * @Date 2020/3/24 19:11
 */
public class SensitivewordFilter {
    private Map sensitiveWordMap;
    public static int minMatchTYpe = 1;      //最小匹配规则
    public static int maxMatchType = 2;      //最大匹配规则
    private static SensitivewordFilter instance = new SensitivewordFilter();

    /**
     * 私有化构造方法
     *  Words.txt词库文件在resource下
     */
    private SensitivewordFilter() {
        try {
//            Resource resource = new ClassPathResource("‪woed.txt");
//            File file = resource.getFile();
            sensitiveWordMap = new SensitiveWordInit("E:\\admin\\ciku\\data\\中英日文名字库\\Chinese_Names_Corpus（120W）.txt").initKeyWord();
            System.out.println("sensitiveWordMap = " + sensitiveWordMap);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 单例模式只初始化一次
     * @return
     */
    public static SensitivewordFilter getInstance() {
        return instance;
    }

    /**
     * 判断文字是否包含敏感字符
     *
     * @param txt       文字
     * @param matchType 匹配规则&nbsp;1：最小匹配规则，2：最大匹配规则
     * @return 若包含返回true，否则返回false
     */
    public boolean isContaintSensitiveWord(String txt, int matchType) {
        boolean flag = false;
        for (int i = 0; i < txt.length(); i++) {
            //判断是否包含敏感字符
            int matchFlag = this.CheckSensitiveWord(txt, i, matchType);
            if (matchFlag > 0) {
                //大于0存在，返回true
                flag = true;
            }
        }
        return flag;
    }

    /**
     * 获取文字中的敏感词
     *
     * @param txt       文字
     * @param matchType 匹配规则&nbsp;1：最小匹配规则，2：最大匹配规则
     *                  比如说我是中国人，铭感词库里面有“中国”、“中国人”，最小规则就变成了：我是**人、最大规则就是：我是***。
     *                  所以最小规则就是：找到敏感词就结束，最大规则就是：找到最底层的那个敏感词。两个深度不一样！
     * @return
     */
    public Set<String> getSensitiveWord(String txt, int matchType) {
        Set<String> sensitiveWordList = new HashSet<>();
        for (int i = 0; i < txt.length(); i++) {
            //判断是否包含敏感字符
            int length = CheckSensitiveWord(txt, i, matchType);
            if (length > 0) {
                //存在,加入list中
                sensitiveWordList.add(txt.substring(i, i + length));
                //减1的原因，是因为for会自增
                i = i + length - 1;
            }
        }
        return sensitiveWordList;
    }

    /**
     * 替换敏感字字符
     *
     * @param txt
     * @param matchType
     * @param replaceChar 替换字符，默认*
     */
    public String replaceSensitiveWord(String txt, int matchType, String replaceChar) {
        String resultTxt = txt;
        //获取所有的敏感词
        Set<String> set = getSensitiveWord(txt, matchType);
        Iterator<String> iterator = set.iterator();
        String word;
        String replaceString;
        while (iterator.hasNext()) {
            word = iterator.next();
            replaceString = getReplaceChars(replaceChar, word.length());
            resultTxt = resultTxt.replaceAll(word, replaceString);
        }

        return resultTxt;
    }

    /**
     * 获取替换字符串
     *
     * @param replaceChar
     * @param length
     * @return
     */
    private String getReplaceChars(String replaceChar, int length) {
        String resultReplace = replaceChar;
        for (int i = 1; i < length; i++) {
            resultReplace += replaceChar;
        }
        return resultReplace;
    }

    /**
     * 检查文字中是否包含敏感字符，检查规则如下：<br>
     *
     * @param txt
     * @param beginIndex
     * @param matchType
     * @return，如果存在，则返回敏感词字符的长度，不存在返回0
     */
    @SuppressWarnings({"rawtypes"})
    public int CheckSensitiveWord(String txt, int beginIndex, int matchType) {
        //敏感词结束标识位：用于敏感词只有1位的情况
        boolean flag = false;
        //匹配标识数默认为0
        int matchFlag = 0;
        char word = 0;
        Map nowMap = sensitiveWordMap;
        for (int i = beginIndex; i < txt.length(); i++) {
            word = txt.charAt(i);
            //获取指定key
            nowMap = (Map) nowMap.get(word);
            if (nowMap != null) {
                //存在，则判断是否为最后一个
                matchFlag++;
                //找到相应key，匹配标识+1
                if ("1".equals(nowMap.get("isEnd"))) {
                    //如果为最后一个匹配规则,结束循环，返回匹配标识数
                    flag = true;
                    //结束标志位为true
                    if (SensitivewordFilter.minMatchTYpe == matchType) {
                        //最小规则，直接返回,最大规则还需继续查找
                        break;
                    }
                }
            } else {
                //不存在，直接返回
                break;
            }
        }
        if (matchFlag < 2 || !flag) {
            //长度必须大于等于1，为词
            matchFlag = 0;
        }
        return matchFlag;
    }

    public static void main(String[] args) {
        long beginTime = System.currentTimeMillis();
        SensitivewordFilter filter = SensitivewordFilter.getInstance();
        System.out.println("敏感词的数量：" + filter.sensitiveWordMap.size());
        String string = "张宇";

        System.out.println("被检测字符串长度：" + string.length());
        String newStr = filter.replaceSensitiveWord(string, 2, "*");
        long endTime = System.currentTimeMillis();
        Set<String> set = filter.getSensitiveWord(string, 1);
        System.out.println("语句中包含敏感词的个数为：" + set.size() + "。包含：" + set);
        System.out.println("总共耗时：" + (endTime - beginTime) + "ms");
        System.out.println("替换后的字符串为：\n" + newStr);
    }
}
